GermanWikipedia - /page/entry.mu

Micron Document

`:top

Ein `!Schachprogramm`! ist ein `F33f`_`[Computerprogramm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f, das in der Lage ist, `F33f`_`[Schach`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schach]`_`f zu spielen. Nach den kommerziellen Anfängen in den 1970er-Jahren, in denen erste zum Schachspielen speziell angefertigte `F33f`_`[Schachcomputer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schachcomputer]`_`f im Handel angeboten wurden, läuft es inzwischen zumeist auf handelsüblichen `F33f`_`[Computern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Personal_Computer]`_`f (PCs) oder auf diversen `F33f`_`[Mobilgeräten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mobilgerät]`_`f wie beispielsweise den allgegenwärtigen `F33f`_`[Handys`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mobiltelefon]`_`f. Die Entwicklung von Schachprogrammen ist eine Disziplin des `F33f`_`[Computerschachs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerschach]`_`f.

Während bei früheren Schachprogrammen die gesamte Funktionalität in einem Programm vereint war, besteht moderne Schachsoftware in der Regel aus zwei Teilen: der sogenannten `*`F33f`_`[Engine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Engine]`_`f`*, der „Maschine“, das die vom Computer gespielten `F33f`_`[Züge`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Spielzug]`_`f berechnet, und dem `F33f`_`[Schach-Frontend`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schach-Frontend]`_`f, der „Oberfläche“, das deren Darstellung und die Benutzerinteraktion übernimmt. Für die interne Kommunikation zwischen Engine und Frontend gibt es zwei weit verbreitete offene Schach-`F33f`_`[Kommunikationsprotokolle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kommunikationsprotokoll]`_`f: das `F33f`_`[XBoard`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=XBoard]`_`f-Protokoll und das neuere `F33f`_`[Universal Chess Interface`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Universal_Chess_Interface]`_`f (UCI). Die Stellungen und Partien werden in `F33f`_`[proprietären`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Proprietär]`_`f Formaten oder im offenen `F33f`_`[Portable-Game-Notation-Format`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Portable_Game_Notation]`_`f (PGN) gespeichert.

>>Contents

• `F0af`_`[Aktuelle Programme`#aktuelle-programme]`_`f

• `F0af`_`[Graphische Schachfrontends`#graphische-schachfrontends]`_`f

• `F0af`_`[Engines`#engines]`_`f

• `F0af`_`[Aufbau`#aufbau]`_`f

• `F0af`_`[Zuggenerator und interne Brettdarstellung`#zuggenerator-und-interne-brettdarstellung]`_`f

• `F0af`_`[Bewertungsfunktionen`#bewertungsfunktionen]`_`f

• `F0af`_`[Steuerung der Suche und Zugauswahl`#steuerung-der-suche-und-zugauswahl]`_`f

• `F0af`_`[Bibliotheken und Datenbanken`#bibliotheken-und-datenbanken]`_`f

• `F0af`_`[Geschichte`#geschichte]`_`f

• `F0af`_`[Konrad Zuse`#konrad-zuse]`_`f

• `F0af`_`[Alan Turing`#alan-turing]`_`f

• `F0af`_`[Claude Shannon`#claude-shannon]`_`f

• `F0af`_`[Dietrich Prinz`#dietrich-prinz]`_`f

• `F0af`_`[John von Neumann`#john-von-neumann]`_`f

• `F0af`_`[Richard Greenblatt`#richard-greenblatt]`_`f

• `F0af`_`[Peter Jennings`#peter-jennings]`_`f

• `F0af`_`[Ken Thompson`#ken-thompson]`_`f

• `F0af`_`[Feng-hsiung Hsu`#feng-hsiung-hsu]`_`f

• `F0af`_`[Chrilly Donninger und Ulf Lorenz`#chrilly-donninger-und-ulf-lorenz]`_`f

• `F0af`_`[Aktuelle Entwicklungen`#aktuelle-entwicklungen]`_`f

• `F0af`_`[Wettbewerbe`#wettbewerbe]`_`f

• `F0af`_`[Elo-Zahlen`#elo-zahlen]`_`f

• `F0af`_`[Siehe auch`#siehe-auch]`_`f

• `F0af`_`[Quellen`#quellen]`_`f

• `F0af`_`[Literatur`#literatur]`_`f

• `F0af`_`[Weblinks`#weblinks]`_`f

-─

>>Aktuelle Programme

>>>Graphische Schachfrontends

Schachprogramme stehen auf vielen Geräten und Betriebssystemen zur Verfügung.

Zur komfortablen Bedienung wird eine als Schach-Frontend bezeichnete Benutzeroberfläche benötigt. Hierzu kann beispielsweise das Programm `F33f`_`[XBoard`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=XBoard]`_`f genutzt werden. Es läuft unter den Betriebssystemen `F33f`_`[Microsoft Windows`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows]`_`f (unter dem Namen `F33f`_`[WinBoard`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=WinBoard]`_`f), `F33f`_`[Unix`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unix]`_`f/`F33f`_`[Linux`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Linux]`_`f und `F33f`_`[Amiga`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Amiga]`_`f und wird zusammen mit `F33f`_`[GNU Chess`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GNU_Chess]`_`f ausgeliefert. Ein graphisches `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f-basierendes Schach-Frontend mit Datenbankfunktionen ist das ebenfalls unter der `F33f`_`[GPL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GPL]`_`f veröffentlichte `F33f`_`[José`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=José_(Schach)]`_`f. Eine weitere beliebte Benutzeroberfläche unter Windows für mehr als 250 Schachprogramme ist `F33f`_`[Arena`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Arena_(Schach)]`_`f, die als Freeware verfügbar ist. Es gibt auch weitere Freeware, die sich für den Einsteiger eignet, so beispielsweise Arasan.`:cite-ref-1[`F5bf`_`[1`#cite-note-1]`_`f] Das Schach-Frontend von `F33f`_`[KDE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=KDE]`_`f ist Knights.`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f]

Inzwischen kann man hochklassiges Schach auch auf `F33f`_`[Mobiltelefonen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mobiltelefon]`_`f, `F33f`_`[PDAs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Personal_Digital_Assistant]`_`f und sonstigen `F33f`_`[Handhelds`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Handheld]`_`f spielen. Auf `F33f`_`[Palm-OS-basierten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Palm_OS]`_`f Geräten steht beispielsweise mit `F33f`_`[OpenChess`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OpenChess]`_`f ein freies Schachprogramm zur Verfügung, das die Auswahl zwischen mehreren Schachengines bietet.

Ambitionierte Spieler greifen oft zu kommerziellen Programmen, die neben dem reinen Schachspiel auch viele Zusatzmöglichkeiten bieten, wie beispielsweise Partieanalyse und Schachtraining. Sehr bekannt dürften die Programme `F33f`_`[Shredder`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Shredder_(Schachprogramm)]`_`f und `F33f`_`[Fritz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fritz_(Schachprogramm)]`_`f sein. Diese Programme werden unter anderem von der Hamburger Firma `F33f`_`[ChessBase`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ChessBase]`_`f vertrieben, die den (europäischen) Markt für professionelle Schachsoftware zunehmend beherrscht.

>>>Engines

Seit Mitte der 2000er Jahre sind Schachengines stärker als menschliche Spieler. Sie werden seitdem häufiger zum Training genutzt oder mit speziellen Einstellungen, die die Spielstärke beschränken, genutzt. Beispielsweise `*Ufim`* bietet die Möglichkeit einer solchen Beschränkung.`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]

Das Open-Source-Programm `F33f`_`[Stockfish`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stockfish]`_`f ist für verschiedene `F33f`_`[Betriebssysteme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Betriebssystem]`_`f mit `F33f`_`[32-Bit-`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=32-Bit-Architektur]`_`f oder `F33f`_`[64-Bit-Architektur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=64-Bit-Architektur]`_`f verfügbar und zählt zu den spielstärksten Schachprogrammen überhaupt. Wegen seiner offenen Entwicklung steht Stockfish nicht in Verdacht, ein Plagiat zu sein. Es ist kostenlos erhältlich.

Die Spielstärke von Schachengines wird in eigenen Turnieren ermittelt und verglichen. In der Top Chess Engine Chess Championship dominieren seit Saison 9, also 2016 Stockfish und LCZero und lösten die Dominanz von Komodo und Houdini ab.`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]

>>>>Anfänge und frühe Kontroversen

Eines der bekanntesten kostenlos erhältlichen Schachprogramme ist `F33f`_`[Crafty`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Crafty]`_`f, ein `F33f`_`[Open-Source-Projekt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Open_Source]`_`f von `F33f`_`[Robert Hyatt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Robert_Hyatt]`_`f. Ein weiteres spielstarkes Schachprogramm ist `F33f`_`[Fruit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fruit_(Schachprogramm)]`_`f, das bei der Weltmeisterschaft im Computerschach 2005 den zweiten Platz belegte. Bis zur Version 2.1 ist Fruit ebenfalls unter einer Open-Source-Lizenz erhältlich, genauso wie das ungefähr gleich starke Glaurung 2.1. Stockfish führt die Entwicklung von Glaurung Open Source fort.

Das kommerzielle Programm `F33f`_`[Houdini`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Houdini_(Schach)]`_`f gehört seit Jahren zu den spielstärksten,`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] ist allerdings umstritten. Der Programmierer des Schachprogramms `F33f`_`[Rybka`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rybka]`_`f behauptet, ihm sei `F33f`_`[Quelltext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f gestohlen worden und auf dieser Basis seien diverse, sehr spielstarke Schachprogramme (`F33f`_`[IPPOLIT`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IPPOLIT]`_`f-Familie) entstanden, darunter auch Houdini. Ein Beleg für diese Behauptung wurde – zumindest öffentlich – nicht erbracht. Dem Programmierer des Schachprogramms Rybka wiederum wird nachgesagt, sein Programm Rybka basiere auf Fruit.`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f] Aufgrund dieser Kontroversen wurde Houdini – ebenso wie einige andere Programme der Ippolit-Familie – von diversen Ranglistenbetreibern zeitweilig nicht gelistet. Im weiteren Verlauf wurde das Programm Rybka als Plagiat von `F33f`_`[Fruit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fruit_(Schachprogramm)]`_`f eingestuft, wodurch Rybka alle Titel und Erfolge aberkannt wurden. Der Programmierer von Rybka wurde auf Lebenszeit für alle Computerschachturniere gesperrt. Houdini hingegen, das wiederum auf Rybka basieren soll, war dann anerkannt die stärkste Schach-Engine und wurde zusammen mit dem Frontend Aquarium bei den Schachweltmeisterschaften zur `F33f`_`[Analyse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Analyse_(Schach)]`_`f genutzt.

Seit 2005 sorgte das Programm `F33f`_`[Rybka`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rybka]`_`f für Schlagzeilen in Fachzeitschriften und Computerforen. Rybka hat ausgeprägte Fertigkeiten auf positionellem, `F33f`_`[schachstrategischem`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Strategie_(Schach)]`_`f Terrain und ist damit der menschlichen Spielweise näher gekommen als die meisten anderen Schachprogramme. Rybka führte die wichtigsten Computerschach-Ranglisten mit 50–150 Punkten Vorsprung an. Schachgroßmeister wie `F33f`_`[Anand`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Viswanathan_Anand]`_`f, `F33f`_`[Topalow`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wesselin_Topalow]`_`f oder `F33f`_`[Morosewitsch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Alexander_Sergejewitsch_Morosewitsch]`_`f nutzten Rybka zur Analyse, inzwischen wird häufiger Stockfish, Critter oder Houdini eingesetzt.

Seit 2014 werden die `F33f`_`[Rankinglisten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rangordnung]`_`f, die mittels Partien zwischen den Programmen ermittelt werden, vom kommerziellen Programm `F33f`_`[Komodo`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Komodo_(Schach)]`_`f und der oben beschriebenen Open-Source-Entwicklung Stockfish Kopf an Kopf angeführt.`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]`:cite-ref-8[`F5bf`_`[8`#cite-note-8]`_`f]`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f]`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f]`:cite-ref-11[`F5bf`_`[11`#cite-note-11]`_`f]

>>Aufbau

Die Hauptbestandteile eines Schachprogramms sind der `*Zuggenerator,`* die `*Bewertungsfunktion`* und ein Programmteil zur `*Steuerung der Suche`* und der Auswahl des nächsten Zuges. Von der aktuellen Stellung (Spielsituation) ausgehend, führt das Programm eine `F33f`_`[iterative Tiefensuche`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Iterative_Tiefensuche]`_`f durch. In jeder Iteration führt es verschiedene Zugfolgen der Reihe nach aus, bewertet die erreichten Stellungen (Blätter des `F33f`_`[Suchbaums`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Suchbaum]`_`f) mit der Bewertungsfunktion, und von diesen Blattwerten ausgehend bewertet es nach dem `F33f`_`[Minimax-Prinzip`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Minimax-Prinzip]`_`f die inneren Knoten des Suchbaums und damit auch die Züge, die jeweils zu einem Knoten führen. Nach der letzten Iteration spielt es den höchstbewerteten Zug im Wurzelknoten (der die aktuelle Stellung repräsentiert).

Ein wichtiges Merkmal eines Schachprogramms ist die Art der `*internen Brettdarstellung,`* derer sich alle anderen Bestandteile des Programms bedienen.

>>>Zuggenerator und interne Brettdarstellung

Der Zuggenerator erzeugt eine Liste aller in einer bestimmten Stellung legalen (regelkonformen) Züge (mögliche Bewegungen der Spielfiguren). In der Anfangsstellung sind 20 Züge möglich (16 Bauernzüge, 4 Springerzüge), im weiteren Spielverlauf kann man im Mittel mit etwa 40 legalen Zügen in jeder Stellung rechnen, im `F33f`_`[Endspiel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Endspiel_(Schach)]`_`f weniger. Der Zuggenerator muss auch komplizierte Züge wie `F33f`_`[Rochaden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rochade]`_`f, Bauernumwandlungen und `F33f`_`[En-passant-Schläge`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=En_passant]`_`f berücksichtigen.

In der Regel lässt man den Zuggenerator alle pseudolegalen Züge berechnen, d. h., die Königsregel wird nicht beachtet; z. B. könnte ein solcher Zug den König auf ein bedrohtes Feld ziehen. Der Zuggenerator wird dadurch erheblich einfacher und schneller. Die illegalen Züge werden später durch den Programmteil zur Steuerung der Suche aussortiert: Ein Zug war illegal, wenn die darauf folgende Zugliste einen Zug enthält, der den König schlägt.

Zur `F33f`_`[Kodierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kodierung]`_`f der Figuren werden hier in den Beispielen folgende Ganzzahlen verwendet:

| Figur | Kodierung | Kodierung |

|---|---|---|

| Figur | Weiß | Schwarz |

| Leeres Feld | 0 | 0 |

| Bauer | 1 | 2 |

| Turm | 11 | 21 |

| Springer | 12 | 22 |

| Läufer | 13 | 23 |

| Dame | 14 | 24 |

| König | 10 | 20 |

| Ungültiges Feld | −1 | −1 |

Die Implementierung des Zuggenerators hängt eng mit der internen Brettdarstellung zusammen. Hier gibt es vier wichtige Vertreter:

>>>>12×10-Darstellung

| −1 (0) | −1 (1) | −1 (2) | −1 (3) | −1 (4) | −1 (5) | −1 (6) | −1 (7) | −1 (8) | −1 (…) |

|---|---|---|---|---|---|---|---|---|---|

| −1 (10) | −1 | −1 | −1 | −1 | −1 (15) | −1 | −1 | −1 | −1 (19) |

| −1 (20) | 21 | 22 | 23 | 24 | 20 | 23 | 22 (27) | 21 | −1 |

| −1 | 2 | 2 | 2 | 2 | 0 (35) | 2 | 2 | 2 | −1 (39) |

| −1 | 0 | 0 | 0 | 0 | 0 | 0 (46) | 0 | 0 (48) | −1 |

| −1 | 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 | −1 |

| −1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | −1 |

| −1 | 0 | 0 | 12 | 0 | 0 | 0 | 0 | 0 | −1 |

| −1 | 1 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | −1 |

| −1 | 11 | 0 | 13 | 14 | 10 | 13 | 12 | 11 | −1 |

| −1 | −1 | −1 | −1 | −1 | −1 | −1 | −1 | −1 | −1 |

| −1 | −1 | −1 | −1 | −1 (…) | −1 (115) | −1 (116) | −1 (117) | −1 (118) | −1 (119) |

Das Spielbrett wird auf ein eindimensionales und 120 Elemente großes `F33f`_`[Array`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Feld_(Datentyp)]`_`f abgebildet. Der Index (Zahlen in Klammern) läuft in der Regel zeilenweise, hier von 0 (links oben) bis 119 (rechts unten). Zusätzlich zu den 64 gültigen Feldern enthält das Array Felder, die eine Figur beim Verlassen des Brettes erreichen würde und die quasi einen Rand um das reguläre Brett bilden. Auf diesen Randfeldern wird ein bestimmter Wert (hier −1) gespeichert, und wenn eine Figur auf ein Feld mit diesem Eintrag ziehen würde, heißt das, dass sie damit das Brett verlassen würde. Dies kann leicht abgefragt werden, da man ohnehin nachsehen muss, ob das Zielfeld von einer eigenen Figur besetzt ist, wodurch der Zug illegal wäre. Diese Technik macht den Zuggenerator einfach und schnell. Der linke und rechte Rand an jeder Seite muss nur ein Feld groß sein, denn ein Springer, der seitlich vom Brett zieht, landet immer entweder auf der linken oder der rechten Randreihe.

Durch Addition der folgenden Konstanten zu einem Feldindex lassen sich die möglichen Zielfelder für eine Figur auf diesem Feld bestimmen.

| Bewegung | Konstanten |

|---|---|

| Horizontale und vertikale Bewegung (Turm, Dame, König) | −10, −1, +1, +10 |

| Diagonale Bewegung (Läufer, Dame, König) | −11, −9, +9, +11 |

| Bewegung wie ein Springer | −21, −19, −12, −8, +8, +12, +19, +21 |

Betrachten wir den schwarzen Springer auf Feld 27 (Sg8). Die Addition dieser Konstanten zu 27 ergibt die potentiellen Zielfelder: 6, 8, 15, 19, 35, 39, 46 und 48. Ist der Wert im Zielfeld −1, dann ist der Zug nicht möglich, da der Springer über den Rand ziehen würde. Ist der Wert 1 oder 10 bis 14, ist eine weiße Figur auf dem Feld, die geschlagen werden kann, und ist er gleich Null, ist ein Zug auf das leere Feld möglich. Der Springer kann hier also drei verschiedene Züge auf die Zielfelder 35, 46 und 48 ausführen, die der Zugliste hinzugefügt werden. Falls der Zuggenerator nur legale Züge – und nicht alle pseudolegalen – erzeugen soll, muss man noch beachten, ob der Springer gefesselt ist oder ein Schachgebot besteht, das man abwehren muss.

Ähnlich geht es mit den anderen Figurenarten. Die langschrittigen (Dame, Läufer, Turm) können ein besetztes Feld nicht überspringen. Nachdem ein solches erreicht wurde, ist in dieser Richtung kein weiterer Zug möglich und man geht zur nächsten Zugrichtung.

Während der Zuggenerator recht einfach aufgebaut und schnell ist, sind die statischen Bewertungsfunktionen langsamer.

>>>>8×8-Darstellung

| 21 | 22 | 23 | 24 | 20 | 23 | 22 | 21 |

|---|---|---|---|---|---|---|---|

| 2 | 2 | 2 | 2 | 0 | 2 | 2 | 2 |

| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |

| 0 | 0 | 0 | 0 | 2 | 0 | 0 | 0 |

| 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |

| 0 | 0 | 12 | 0 | 0 | 0 | 0 | 0 |

| 1 | 1 | 1 | 1 | 0 | 1 | 1 | 1 |

| 11 | 0 | 13 | 14 | 10 | 13 | 12 | 11 |

Die 8×8-Darstellung ist der menschlichen Sicht am nächsten. Das Programm `F33f`_`[GNU Chess`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GNU_Chess]`_`f verwendete sie bis Version 4. Das Brett wird, wie auch bei 12×10, als eindimensionales Array modelliert, hier mit Indexbereich 0 bis 63 (alternativ 1 bis 64). Ein zweidimensionales Array scheint näherliegend, ist aber langsamer, denn ein Feld muss hier mit zwei Zahlen (Reihe und Linie) bezeichnet werden, zu beiden muss bei der Zugerzeugung eine Konstante addiert werden, und beim Zugriff auf ein Feld ist die Adressberechnung mit zwei Indizes komplizierter.

Der Zuggenerator ist normalerweise komplexer und langsamer als bei der 12×10-Darstellung, da die Spezialfälle am Rand gesondert behandelt werden müssen. Die statische Bewertungsfunktion arbeitet allerdings effizienter, da Reihe und Linie, auf denen ein Feld liegt, mit schnellen `F33f`_`[Bitoperationen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bitweiser_Operator]`_`f bestimmt werden können: UND-Verknüpfen des Index mit 7 ergibt die Linie und Rechtsschieben um 3 Bit die Reihe (bei zeilenweiser Felderanordnung und Indexbereich 0 bis 63). Beim 12×10-Brett muss man hingegen durch 10 dividieren. Die Bewertungsfunktion benötigt diese Information oft, z. B. zur Doppelbauern- oder `F33f`_`[Isolani`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Isolani_(Schach)]`_`f-Erkennung.

Auch mit dem 8×8-Brett ist eine schnelle und einfache Zugerzeugung mittels Tabellenzugriff möglich, was aber den Speicherverbrauch erheblich erhöht. GNU Chess verwendet für jede Figurenart ein zweidimensionales Array `*nextpos`* mit 64 mal 64 Elementen, dessen Einträge vorab berechnet werden. Indiziert man es mit dem Ausgangsfeld `*f`* einer Figur und einem ihrer Zielfelder, liest man das nächste Zielfeld für die Figur daraus ab. `*nextpos(f,f)`* liefert das erste Zielfeld. Für die langschrittigen Figuren gibt es zusätzlich das Array `*nextdir`*, aus dem bei besetztem Zielfeld das nächste Zielfeld gelesen wird (erstes Feld in einer neuen Zugrichtung). Gibt es kein Zielfeld mehr, liefern beide wieder den Wert `*f.`*

Eine andere Möglichkeit ist ein dreidimensionales Array, das für alle Felder und Figurentypen alle Zielfelder enthält, die diese Figur von diesem Feld aus erreichen kann. Der dritte Index läuft über diese Zielfelder. Der Speicherverbrauch ist hier niedriger, besonders wenn man ein zweidimensionales Array von Zeigern verwendet, die jeweils auf ein `F33f`_`[Halden-Array`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dynamischer_Speicher]`_`f passender Größe zeigen, entsprechend der unterschiedlichen Anzahl der Zielfelder. Die Einträge sind zweiteilig: Der erste Teil ist der Zielfeldindex und der zweite ist die Anzahl der im Array darauf folgenden Felder, die bei besetztem Zielfeld zu übergehen sind (oder direkt der nächste Index in das Array).

>>>>0x88-Darstellung

Diese ist eine Weiterentwicklung der 8×8-Darstellung. Bei zeilenweiser Darstellung mit 16 Feldern je Zeile bildet der linke Bereich von 8 mal 8 Feldern das Schachbrett, der rechte Bereich von 8 mal 8 Feldern wird nicht verwendet. Wenn eine Figur über den Rand ziehen würde, erkennt man das durch `F33f`_`[bitweise UND-Verknüpfung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bitweiser_Operator]`_`f des Zielfeldindex mit der `F33f`_`[Hexadezimalzahl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hexadezimalsystem]`_`f 0x88 (= 136). Wenn das Ergebnis Null ist, bezeichnet der Feldindex ein gültiges Feld, anderenfalls würde die Figur das Brett verlassen. Reihe und Linie eines Feldes kann man ähnlich wie beim 8×8-Brett durch Rechtsschieben um 4 Bit bzw. UND-Verknüpfen mit 7 berechnen.

Bei dieser Darstellung kann man außerdem anhand der Indexdifferenz zweier Felder ermitteln, ob und mit welcher Figur ein Zug von einem zum anderen Feld möglich ist. Zum Beispiel ist ein Turmzug genau dann möglich, wenn die Differenz im Bereich -7 bis 7 oder ein Vielfaches von 16 ist. Mit der 8×8- oder 10×12-Darstellung geht das nicht, denn das Kriterium wird auch von Feldpaaren erfüllt, die keinen entsprechenden Zug zulassen. Die Felder h4 und a5 zum Beispiel haben dort eine Indexdifferenz kleiner 8, obwohl kein Turmzug möglich ist.

>>>>Bitboards

→

Hauptartikel

Bitboard

Manche modernen Schachprogramme, etwa `F33f`_`[Rybka`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rybka]`_`f, `F33f`_`[Crafty`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Crafty]`_`f oder GNU Chess 5, verwenden `F33f`_`[Bitboards`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bitboard]`_`f. Diese sind besonders effizient auf `F33f`_`[64-Bit-Rechnerarchitekturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=64-Bit-Architektur]`_`f implementierbar, wo die Anzahl der `F33f`_`[Bits`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bit]`_`f eines `F33f`_`[Registers`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Register_(Computer)]`_`f/`F33f`_`[Worts`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datenwort]`_`f mit der Anzahl der Felder übereinstimmt. Jede Bitposition in einem Wort ist einem Feld des Bretts zugeordnet, und durch das Bit an dieser Position wird eine Angabe über das entsprechende Feld gemacht.

Im folgenden Beispiel wird die Stellung nach den Zügen 1. e4 e5 2. Sc3 mit acht Registern von 64 Bit dargestellt. Das Register `B100`F9d9B`f`b enthält überall ein 1-Bit, wo ein Bauer (gleich welcher Farbe) auf dem entsprechenden Feld steht. Auch für die übrigen Figurenarten gibt es je ein Register. `B100`F9d9WEI`f`b und `B100`F9d9SCH`f`b geben an, wo sich eine weiße bzw. eine schwarze Figur befindet. Zur besseren Übersichtlichkeit sind Bits mit dem Wert 0 durch `B100`F9d9-`f`b wiedergegeben.

`B100`F9d9 Reihe 8 7 6 5 4 3 2 1`f`b

`B100`F9d9 Linie abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh abcdefgh`f`b

`B100`F9d9 Bitposition 63 56 48 40 32 24 16 8 0`f`b

`B100`F9d9 Registername | | | | | | | | |`f`b

`B100`F9d9 | | | | | | | | | |`f`b

`B100`F9d9Bauern B -------- 1111-111 -------- ----1--- ----1--- -------- 1111-111 --------`f`b

`B100`F9d9Türme T 1------1 -------- -------- -------- -------- -------- -------- 1------1`f`b

`B100`F9d9Springer S -1----1- -------- -------- -------- -------- --1----- -------- ------1-`f`b

`B100`F9d9Läufer L --1--1-- -------- -------- -------- -------- -------- -------- --1--1--`f`b

`B100`F9d9Damen D ---1---- -------- -------- -------- -------- -------- -------- ---1----`f`b

`B100`F9d9Könige K ----1--- -------- -------- -------- -------- -------- -------- ----1---`f`b

`B100`F9d9Weiss WEI -------- -------- -------- -------- ----1--- --1----- 1111-111 1-111111`f`b

`B100`F9d9Schwarz SCH 11111111 1111-111 -------- ----1--- -------- -------- -------- --------`f`b

Mit schnellen `F33f`_`[bitweisen Operationen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bitweiser_Operator]`_`f kann man nun für alle Felder parallel Informationen über die Stellung berechnen. Zum Beispiel lassen sich durch die UND-Verknüpfung `B100`F9d9T & WEI`f`b alle Positionen der weißen Türme bestimmen, und `B100`F9d9((B & SCH) >> 8) & ~(WEI | SCH)`f`b liefert ein Bitmuster mit den Feldern, auf die ein schwarzer Bauer mit einem Einzelschritt ziehen kann. Dabei bezeichnet `B100`F9d9>>`f`b die `F33f`_`[Bitverschiebung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bitweiser_Operator]`_`f nach rechts (zum niederwertigen Ende), `B100`F9d9~`f`b die Negation und `B100`F9d9|`f`b die ODER-Verknüpfung.

>>>Bewertungsfunktionen

Die `F33f`_`[Bewertungsfunktion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bewertungsfunktion_(Spieltheorie)]`_`f liefert die `F33f`_`[heuristische`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Heuristik]`_`f Bewertung einer Stellung, ohne die Nachfolgezüge zu bestimmen. Sie setzt sich aus einer `*materiellen`* und einer `*positionellen`* Komponente zusammen. Die positionelle Komponente ergänzt die materielle, da die Stärke der Spielfiguren auch von ihren Positionen untereinander abhängen. Vereinfachte Bewertungsfunktionen können auch von menschlichen Spielern ausgeführt werden, was allerdings nur eine historische Bedeutung hat. Computerprogramme zeigen sehr oft die Bewertung einer Spielsituation numerisch (in sogenannten `*`F33f`_`[Bauerneinheiten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bauerneinheit]`_`f`*) an, wobei positive Werte Vorteile und negative Werte Nachteile für einen bestimmten Spieler bedeuten.

>>>>Material

Für die `*materielle`* Wertung werden für die auf dem Brett befindlichen Spielfiguren Werte addiert. Der ungefähre Wert der Figurenarten in 1⁄100 `F33f`_`[Bauerneinheiten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bauerneinheit]`_`f ist in der folgenden Tabelle angegeben.

|---|---|---|---|---|

| 100 | 310 | 320 | 460 | 900 |

Dabei werden die weißen Figuren (bzw. die der am Zug befindlichen Partei) positiv gezählt und die schwarzen (bzw. die der nachziehenden Partei) negativ. Der König braucht nicht mitgezählt zu werden, da beide Parteien während des gesamten Spiels jeweils einen König haben.

>>>>Position

Die `*positionelle`* Wertung zu bestimmen, ist eine Aufgabe von größerer Komplexität, in der sich die verschiedenen Schachprogramme deutlich voneinander unterscheiden. Bei kommerziellen Programmen bleibt sie ein wohlgehütetes Geheimnis. Bei der positionellen Wertung wird versucht, Stellungen aufgrund von schachrelevanten Parametern zu bewerten. Schachrelevante Parameter lassen sich grob klassifizieren in Königssicherheit, Bauernstruktur, beherrschte und bedrohte Felder sowie Figurenentwicklung. So wird zum Beispiel eine Stellung, bei der die Türme noch eingeengt zwischen Springern und Bauern stehen, schlechter bewertet als eine, bei der die Türme schon auf offenen Linien stehen.

Innerhalb dieser Kategorien gibt es quasi beliebig viele Parameter (für `F33f`_`[Bauernstrukturen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bauer_(Schach)]`_`f zum Beispiel `F33f`_`[Freibauer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Freibauer_(Schach)]`_`f, `F33f`_`[Doppelbauer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Doppelbauer_(Schach)]`_`f, `F33f`_`[Hebel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hebel_(Schach)]`_`f, `F33f`_`[Widder`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bauer_(Schach)]`_`f, `F33f`_`[Isolani`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Isolani_(Schach)]`_`f, `F33f`_`[Bauernketten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bauernkette]`_`f; für Königssicherheit zum Beispiel: Kann der König leicht links oder rechts rochieren? Kann er im Zentrum bleiben? Sind Bauern vor dem König?). Es bietet sich an, diese Parameter zunächst wertneutral aus der gegebenen Stellung zu extrahieren. Schachprogrammierer stehen vor der Entscheidung, wie viel Rechenzeit sie für die positionelle Komponente einer ausgefeilten Bewertungsfunktion aufwenden sollen, und welche Parameter überhaupt einfließen sollen: Je tiefer die Schachprogramme den Suchbaum analysieren können, desto eher wird nämlich die Umwandlung positioneller Vorteile in materielle Vorteile sichtbar.

>>>>Statische Bewertungsfunktion

Kann ein Schachprogramm die Werte dieser Parameter pro Stellung effizient bestimmen, müssen diese untereinander gewichtet werden. Die Gewichtung der positionellen Komponente kann teilweise automatisch über das Analysieren von `F33f`_`[Schachdatenbanken`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schachdatenbank]`_`f oder durch Spiele gegen andere Schachprogramme erfolgen. Geschieht dies im Vorfeld der Programmentwicklung, spricht man von einer statischen Bewertungsfunktion. Einfach aufgebaute Bewertungsfunktionen verwenden für die positionelle Komponente Positionsgewichte für die sechs Spielfigurentypen, die aber für Eröffnung, Mittel- und Endspiel jeweils unterschiedlich ausfallen.

Die Bewertungsfunktion kann außer in Grenzfällen wie Endspielen oder Matt- oder Pattsituationen keine objektiv richtigen Ergebnisse liefern. Indem die Bewertungsfunktion die materielle und positionelle Komponente zu einer einzigen Bewertungszahl zusammenfasst, ermöglicht sie aber die Sortierung und Auswahl des „besten“ beziehungsweise „schlechtesten“ Zuges.

Klassischerweise wird der Algorithmus, der eine Stellung nach den einzelnen Kriterien bewertet, vom Programmierer explizit codiert. Heutige Programme bewerten hingegen die Stellungen oft mit einem `F33f`_`[neuronalen Netz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Künstliches_neuronales_Netz]`_`f, das mit einer großen Zahl von Teststellungen trainiert wird. Während der Zugberechnung bekommt es dann die jeweils zu bewertende Stellung (z. B. Blatt des Suchbaums) eingegeben und gibt die Bewertungszahl aus. Damit ein solches Programm schnell läuft, wird in der Regel `F33f`_`[Grafikhardware`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafikprozessor]`_`f zur Auswertung des Netzes genutzt, die zur parallelen Berechnung der Zustände der Netzknoten (Neurone) gut geeignet ist. Manche Programme, beispielsweise `F33f`_`[Stockfish`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stockfish]`_`f, nutzen ein `F33f`_`[NNUE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=NNUE]`_`f (effizient aktualisierbares Netz). Bei geringen Änderungen an einer Stellung (etwa zurücknehmen eines Zugs und ausführen eines anderen) müssen hier nicht alle Knoten des Netzwerks neu ausgewertet werden, sondern nur einige, die von der Änderung betroffen sind. Dadurch kann es auch von einer `F33f`_`[CPU`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozessor]`_`f schnell ausgeführt werden.

>>>>Dynamische Bewertungsfunktion

In der Regel wird die Bewertungsfunktion vom Programmierer implementiert und während des Spieles nicht mehr verändert. Eine erweiterte Möglichkeit besteht darin, während des Spieles vergleichbare Stellungen aus einer Schachdatenbank zu ermitteln und so die Gewichtung der positionellen Parameter zu optimieren. Dies entspricht eher dem menschlichen Ansatz. Ein erfahrener Spieler berücksichtigt Kriterien wie Königssicherheit oder Freibauern auch unter Einbeziehung ihm bekannter Partien und deren Ergebnissen.

>>>Steuerung der Suche und Zugauswahl

Grundsätzlich basiert die Steuerung der Suche auf dem `F33f`_`[Spielbaum`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Extensivform_eines_Spiels]`_`f. Er enthält, beginnend bei der aktuellen Stellung (Wurzelknoten), alle Züge des Anziehenden, darauf wieder alle möglichen Antwortzüge des Nachziehenden und so weiter, jeweils bis zum Erreichen einer Endstellung (Matt, Patt, technisches Remis oder Stellungswiederholung). Der Spielbaum ist meist viel zu groß, um ihn vollständig durchzurechnen, deshalb beschränkt sich das Programm auf einen Teil davon (Suchbaum).

Im einfachsten Fall arbeitet das Programm nach der `F33f`_`[A-Strategie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=A-Strategie]`_`f, d. h., es berechnet alle möglichen Zugfolgen bis zu einer bestimmten Tiefe (Zahl der aufeinanderfolgenden Züge), die durch die Rechenleistung und die verfügbare Zeit begrenzt wird. Jede dabei entstehende Stellung wird bewertet. Ist es keine Endstellung wie etwa ein Matt, wird die heuristische Bewertungsfunktion eingesetzt. Mit dem `F33f`_`[Minimax-Algorithmus`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Minimax-Algorithmus]`_`f werden die Züge in der Wurzelstellung bewertet und der höchstbewertete gespielt.

Da die Anzahl der zu untersuchenden Stellungen exponentiell mit der Tiefe wächst, andererseits eine höhere Tiefe eine entsprechende Spielstärkeverbesserung bringt, hat man in den rund 50 Jahren der Programmentwicklung ein ganzes Arsenal an Beschleunigungsmaßnahmen erfunden, die man in zwei Gruppen einteilen kann. Die einen versuchen, den Suchbaum durch allgemeine `F33f`_`[Algorithmen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Algorithmus]`_`f der Informatik zu verkleinern, so zum Beispiel:

• `F33f`_`[Alpha-Beta-Suche`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Alpha-Beta-Suche]`_`f (Negamax-Verfahren)

• `F33f`_`[Hashtabelle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hashtabelle]`_`f zur Erkennung von Zugumstellungen

• `F33f`_`[Null-Zug-Suche`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Null-Zug-Suche]`_`f

Die Alpha-Beta-Suche schneidet Teile des Suchbaums ab, die für die Ermittlung des höchstbewerteten Zuges im Wurzelknoten nicht betrachtet werden müssen. Diese Technik spart sehr viel: Bei guter Implementierung wird die erreichbare Tiefe annähernd verdoppelt.

Die begrenzte Rechentiefe lässt das Programm oft eine taktische Kombination übersehen. Um das zu mildern, vertieft man einzelne interessante Zugfolgen, zum Beispiel nach Schachgeboten oder Zügen, die die gegnerische Königsstellung schwächen, um Mattkombinationen leichter zu entdecken. Die sogenannte `*Recapture-Heuristik`* vertieft Zugfolgen, die einen Abtausch enthalten, um die Folgen des Tausches besser abschätzen zu können. Die Methode der `*`F33f`_`[singular extensions`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Singular_extensions]`_`f`* (`F33f`_`[deutsch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deutsche_Sprache]`_`f „vereinzelte Erweiterungen“) vertieft die Suche für erzwungene (forcierte) Zugfolgen, also in Fällen, bei denen es für eine oder beide Seiten jeweils nur eine einzige „vernünftige“ Antwort gibt.

Weitere Techniken zur Beschleunigung sind die Verwendung vereinfachter Bewertungsfunktionen nach Zugfolgen, die als wenig sinnvoll eingeschätzt werden, sowie die inkrementelle Bewertung, die den Wert einer Stellung nicht immer neu berechnet, sondern bei Ausführung eines Zuges aktualisiert. Manche Programme erledigen einen Großteil der Bewertungsarbeit durch Analysieren der Wurzelstellung und speichern die Ergebnisse in Datenstrukturen, die dann die Blattbewertung erheblich vereinfachen und beschleunigen (z. B. Figuren-Felder-Tabellen).

Manche Programme berechnen nicht (oder nicht immer) alle Züge, die in einer Stellung möglich sind (`F33f`_`[B-Strategie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=B-Strategie]`_`f). Die Werte der Züge werden heuristisch abgeschätzt, wonach nur die hoch bewerteten in den Suchbaum aufgenommen werden. Dadurch ahmt man das Verhalten eines menschlichen Spielers nach. Der Suchbaum wird erheblich kleiner, aber man riskiert, dass die Heuristik zuweilen einen guten Zug übersieht. Diese Verfahren sind sehr viel schwieriger zu implementieren als die A-Strategie. Auch lassen sie sich nicht ohne weiteres auf andere Spiele wie `F33f`_`[Go`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Go_(Spiel)]`_`f übertragen, denn die Kriterien der Zugauswahl sind dann völlig andere.

Man darf die Berechnung nicht abbrechen und die Blattbewertung durchführen, wenn die Partie gerade mitten in einem Abtausch ist, dies würde eine verzerrte Materialbilanz liefern. Hat eine Partei gerade eine gedeckte Figur geschlagen und wird hier bewertet, erhält man ein unechtes Materialübergewicht für diese Partei. Eine oft angewandte Abhilfe ist die sogenannte Ruhesuche (quiesence-search): In einer Blattstellung berechnet man noch alle Schlagzüge, und darauf wieder nur die schlagenden Antwortzüge usw., wobei meist noch die weniger aussichtsreichen Schlagzüge abgeschnitten werden, und außerdem wird die maximale Länge der Schlagzugfolgen begrenzt, damit das ganze nicht zu viel Zeit braucht. In jeder so erreichten Stellung erfolgt die Blattbewertung durch die heuristische Bewertungsfunktion, und der Wert der Stellung ist das Maximum aus dem Blattwert und den Werten der Schlagzüge. Der Blattwert steht für die Werte der nicht schlagenden Züge, denn es kann sein, das jeder Schlagzug ein Fehler wäre und es am besten ist, nicht zu schlagen.

>>>Bibliotheken und Datenbanken

>>>>Eröffnungsbibliothek

→

Hauptartikel

Eröffnungstabelle

Schach wird im Wettkampf auf Zeit gespielt, das heißt, für eine Anzahl von Zügen steht nur eine definierte Zeit zur Verfügung. Viele Schachprogramme sind daher mit einer Eröffnungsbibliothek ausgestattet, in der sehr viele „gute“ Zugreihenfolgen in der Eröffnungsphase von Schachspielen abgespeichert sind. In der Anfangsphase des Schachspiels sieht das Programm in dieser Bibliothek nach, welcher Zug in einer bestimmten Brettstellung der geeignetste ist. Dieses „Nachsehen“ geht schneller, als den Zug auszurechnen. Die so gesparte Rechenzeit steht dem Programm dann in späteren Phasen des Spiels zur Verfügung. Das Verfahren, Brettstellungen einschließlich der „guten“ Züge abzuspeichern, ist nur für Eröffnung und Endspiel sinnvoll, da hier die Anzahl der Brettstellungen noch überschaubar ist. Eröffnungsbibliotheken kommerziell erhältlicher Programme weisen einen immer größer werdenden Umfang auf. Sie werden meist aus Meisterpartien generiert. Dies birgt die Gefahr, dass auch unbemerkte Fehler übernommen werden, die das Programm aus eigener Berechnung nicht spielen würde.

Einen großen Anteil an der Spielstärke hat die Abstimmung der Eröffnungsbibliothek auf die später in der Partie genutzte Bewertungsfunktion.

>>>>Endspieldatenbank

→

Hauptartikel

Endspieldatenbank

Im `F33f`_`[Endspiel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Endspiel_(Schach)]`_`f, wenn nur noch wenige Figuren auf dem Brett sind, kann man den optimalen Zug im Vorhinein durch vollständige Analyse (`F33f`_`[Brute-Force-Methode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Brute-Force-Methode]`_`f) berechnen. Es gibt nicht wenige Endspielstellungen, in denen das menschliche Denken, aber auch die Computeranalyse in Echtzeit völlig überfordert wären. Viele Schachprogramme verwenden deshalb Endspieldatenbanken, die alle möglichen Stellungen mit 3, 4, 5, 6 oder sogar 7 Steinen sowie deren Ausgang (bei optimalem Spiel) enthalten. Das Erstellen von Endspiel-Datenbanken geht auf `F33f`_`[Ken Thompson`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ken_Thompson]`_`f zurück. Die ersten Sechssteiner wurden 1991 von Lewis Stiller vollständig berechnet, seit 2012 sind alle Siebensteiner erfasst.`:cite-ref-12[`F5bf`_`[12`#cite-note-12]`_`f]`:cite-ref-13[`F5bf`_`[13`#cite-note-13]`_`f]

>>>>Schachdatenbank

→

Hauptartikel

Schachdatenbank

Schachdatenbanken enthalten gespielte Partien. Sie helfen zum Beispiel beim Studium von `F33f`_`[Eröffnungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eröffnung_(Schach)]`_`f und bei der Vorbereitung auf die nächsten Gegner.

Für Schachprogramme lassen sich aus dem Datenbestand Eröffnungsbibliotheken generieren. Auch ist es möglich, während der Partie vergleichbare Stellungen aus einer Schachdatenbank zu ermitteln und unter Berücksichtigung des dort verzeichneten Partieverlaufs positionelle Bewertungsparameter (siehe oben) zu optimieren (dynamische Bewertungsfunktion).

>>Geschichte

Die Geschichte des Schachprogramms hängt sehr eng mit der Geschichte des Schachcomputers zusammen und lässt sich zumeist nicht getrennt behandeln. Hier werden lediglich Entwicklungen der grundlegenden Algorithmen beschrieben. Zu den in den letzten Jahren medienwirksam ausgetragenen Wettbewerben mit Weltklassespielern siehe `F33f`_`[Schachcomputer im Spiel gegen Menschen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerschach]`_`f.

>>>Konrad Zuse

→

Hauptartikel

Konrad Zuse

In den Jahren 1942 bis 1945 schrieb Konrad Zuse das weltweit erste Schachprogramm in seiner neu entwickelten Programmiersprache, dem `F33f`_`[Plankalkül`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Plankalkül]`_`f. Erstmals implementiert wurde die Sprache aber erst in den 1970ern.`:cite-ref-14[`F5bf`_`[14`#cite-note-14]`_`f]

>>>Alan Turing

→

Hauptartikel

Alan Turing

Der britische `F33f`_`[Mathematiker`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mathematiker]`_`f und `F33f`_`[Codeknacker`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kryptoanalytiker]`_`f Alan Turing entwickelte ein Verfahren, das jedem möglichen Zug einen Wert zuweist. So sollte immer der jeweils beste Zug errechnet werden. Turings Schachprogramm basierte auf folgenden Grundsätzen:

• Jede `F33f`_`[Figur`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schachfigur]`_`f erhielt einen bestimmten Wert: Bauer = 1; Springer = 3; Läufer = 3,5; Turm = 5; Dame = 10 und König = 1000 (damit dieser niemals geopfert werden konnte).

• Alle weißen Züge und alle schwarzen Gegenzüge wurden untersucht. Wenn Weiß einen Schlagzug ausführen konnte, dann wurden alle Schlagzüge des Gegners, alle darauffolgenden weißen Schlagzüge usw. untersucht, bis die Stellung „tot“ war, das heißt, bis es keine weiteren Schlagzüge und kein Matt gab. In den entstehenden Stellungen wurde eine Figurenzählung durchgeführt und der Zug gewählt, der das meiste Material gewann bzw. am wenigsten verlor. Da jedoch, besonders in der Eröffnungsphase, die meisten zur Auswahl stehenden Züge das gleiche Ergebnis (nahe Null) lieferten, führte Turing auch einige positionelle Bewertungskriterien ein, wie Mobilität (Zugmöglichkeiten), Schlagmöglichkeit, Rochade oder Mattdrohung.

Da es zu der Zeit noch keine geeigneten programmierbaren Rechenmaschinen gab, musste Turing jeden Zug von Hand auf Papier selbst ausrechnen, was einen hohen Zeitaufwand bedeutete. Pro Zug musste er ca. 30 Minuten aufwenden`:cite-ref-15[`F5bf`_`[15`#cite-note-15]`_`f]. Immerhin wurde das Funktionsprinzip augenfällig, nach dem im Grunde auch alle heutigen Schachprogramme noch arbeiten. Die erste Partie seiner „Papiermaschine“ fand im Jahr 1952 statt und soll hier beispielhaft aufgeführt werden:

`!`*Turings Papiermaschine – Alick Glennie, Manchester, 1952`*`!

`*1. e4 e5 2. Sc3 Sf6 3. d4 Lb4 4. Sf3 d6 5. Ld2 Sc6 6. d5 Sd4 7. h4 Lg4 8. a4 Sxf3+ 9. gxf3 Lh5 10. Lb5+ c6 11. dxc6 0–0 12. cxb7 Tb8 13. La6 Da5 14. De2 Sd7 15. Tg1 Sc5 16. Tg5 Lg6 17. Lb5 Sxb7 18. 0–0–0 Sc5 19. Lc6 Tfc8 20. Ld5 Lxc3 21. Lxc3 Dxa4 22. Kd2 (22. h5 hätte den Läufer erobert.) 22. … Se6 23. Tg4 Sd4 (23. … Txb2 24. Lxb2 Txc2+) 24. Dd3 Sb5 25. Lb3 Da6 26. Lc4 Lh5 27. Tg3 Da4 28. Lxb5 Dxb5 29. Dxd6 Td8 0:1`*`:cite-ref-steinweder-friedel-16-0[`F5bf`_`[16`#cite-note-steinweder-friedel-16]`_`f]

Zur „Papiermaschine“ gibt es auch Implementierungen für heutige Computer.`:cite-ref-17[`F5bf`_`[17`#cite-note-17]`_`f]

>>>Claude Shannon

→

Hauptartikel

Claude Shannon

In den `F33f`_`[Bell Laboratories`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bell_Laboratories]`_`f hielt Claude Shannon am 9. März 1949 einen für die Entwicklung von Schachprogrammen entscheidenden Vortrag. Er beschrieb dort die interne Brettdarstellung, die Baumsuche, die Bewertungsfunktion sowie die Zugsuche mit Hilfe des `F33f`_`[Minimax-Algorithmus`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Minimax-Algorithmus]`_`f. Er gab auch schon zwei verschiedene Strategien zur Bestimmung des besten Zuges an: `F33f`_`[A-Strategie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=A-Strategie]`_`f und `F33f`_`[B-Strategie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=B-Strategie]`_`f.

>>>Dietrich Prinz

→

Hauptartikel

Dietrich Prinz

Dietrich Günther Prinz von der `F33f`_`[Universität Manchester`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=University_of_Manchester]`_`f hat im November 1951 für den `F33f`_`[Ferranti-Mark-I-Computer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ferranti_Mark_I]`_`f (GB) ein Programm erstellt, das eine zweizügige Mattaufgabe in 15 Minuten löste. Das Programm gilt als erstes Löseprogramm der Schachgeschichte.`:cite-ref-18[`F5bf`_`[18`#cite-note-18]`_`f]

>>>John von Neumann

→

Hauptartikel

John von Neumann

John von Neumann klassifizierte das Schachspiel in seiner `F33f`_`[Spieltheorie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Spieltheorie]`_`f als Zwei-Personen-`F33f`_`[Nullsummenspiel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Nullsummenspiel]`_`f mit vollständiger Information. Diese Klasse von Problemen (dazu gehört auch `F33f`_`[Tic-Tac-Toe`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tic-Tac-Toe]`_`f) kann mit dem `F33f`_`[Minimax-Algorithmus`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Minimax-Algorithmus]`_`f gelöst werden. Schach ist jedoch zu komplex, um den Suchbaum vollständig abarbeiten zu können. Schachprogramme sind deshalb auf Näherungsverfahren angewiesen.

Das Schachprogramm von John von Neumann wurde Mitte der 1950er Jahre fertiggestellt und lief auf dem 1950 aufgestellten Röhrenrechner `F33f`_`[MANIAC I`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MANIAC_I]`_`f. Zur Vereinfachung wurde nur auf einem 6×6-Brett gespielt. Das Programm spielte insgesamt drei Partien: die erste gegen sich selbst, eine weitere verlor es gegen einen starken Schachspieler, obwohl dieser ihm eine Dame vorgab, und die dritte gewann es gegen eine junge Frau, die erst seit einer Woche Schach spielte und extra für dieses Spiel trainiert hatte.

`!`*MANIAC I – Mensch, Los Alamos, 1956:`*`!

`*(6×6-Brett ohne Läufer, kein Doppelschritt oder Rochade)`*

`*1. d3 b4 2. Sf3 d4 3. b3 e4 4. Se1 a4 5. bxa4 (5. Sd2 nebst 6. Sc4+ Sxc4 7. bxc4 mit gutem Spiel) 5. … Sxa4 6. Kd2 Sc3 7. Sxc3 bxc3+ 8. Kd1 f4 9. a3 Tb6 10. a4 Ta6 11. a5 Kd5 12. Da3 Db5 13. Da2+ Ke5 14. Tb1 Txa5 15. Txb5 Txa2 16. Tb1 (Um 16. … Ta1 matt zu verhindern) 16. … Ta5 17. f3 Ta4 18. fxe4 c4 19. Sf3+ Kd6 20. e5+ Kd5 21. exf6D 21. … Sc5 (22. Dxd4+ Kc6 23. Se5 matt.) 1:0`*`:cite-ref-steinweder-friedel-16-1[`F5bf`_`[16`#cite-note-steinweder-friedel-16]`_`f]

Zum ersten Mal hat ein Mensch gegen ein Schachprogramm verloren. Diese vereinfachte `F33f`_`[Schachvariante`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schachvariante]`_`f wird auch `*Los Alamos Chess`* genannt.

1957 implementierte der IBM-Angestellte Alex Bernstein auf einer `F33f`_`[IBM 704`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IBM_704]`_`f ein Schachprogramm, das nach den Standardregeln spielte. Es selektierte in jeder Stellung die sieben plausibelsten Züge und führte eine Suche von 4 Halbzügen durch, was ungefähr 8 Minuten Rechenzeit erforderte. Bernstein erhielt bei der Entwicklung Unterstützung durch den amerikanischen Großmeister `F33f`_`[Arthur Bisguier`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Arthur_Bisguier]`_`f. Das Programm verlor chancenlos gegen den Schachmeister `F33f`_`[Edward Lasker`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Edward_Lasker]`_`f, der dem Computer jedoch ein passables Amateurniveau bescheinigte.

1958 wurde die `F33f`_`[Alpha-Beta-Suche`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Alpha-Beta-Suche]`_`f von `F33f`_`[Allen Newell`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Allen_Newell]`_`f, John Clifford Shaw und `F33f`_`[Herbert A. Simon`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Herbert_A._Simon]`_`f entdeckt und brachte einen gewaltigen Leistungsschub.

>>>Richard Greenblatt

→

Hauptartikel

Richard Greenblatt

Das erste Programm, das an menschlichen Turnieren teilnahm, war `*`F33f`_`[Mac Hack`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mac_Hack]`_`f,`* das von 1965 bis 1967 von Richard Greenblatt am `*`F33f`_`[MIT`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Massachusetts_Institute_of_Technology]`_`f`* entwickelt wurde.

`!`*`F33f`_`[Hubert Dreyfus`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hubert_Dreyfus]`_`f – MacHack, MIT, 1967`*`!

`*1. e4 e5 2. Sf3 Sc6 3. Lc4 Sf6 4. Sc3 Lc5 5. d3 0–0 6. Sg5 Sa5 7. Ld5 c6 8. Lb3 Sxb3 9. cxb3 h6 10. Sh3 d5 11. exd5 Lg4 12. f3 Lxh3 13. gxh3 Sxd5 14. Sxd5 Dxd5 15. Ld2 Dxd3 16. b4 Le7 17. Tg1 e4 18. fxe4 Lh4+ 19. Tg3 Lxg3+ 20. hxg3 Dxg3+ 21. Ke2 Dxh3 22. Dg1 h5 23. Lc3 g6 24. Df2 h4 25. Df6 Dg4+ 26. Kd2 Tad8+ 27. Kc2 Dxe4+ 28. Kb3 De6+ 29. Dxe6 fxe6 30. Th1 Tf4 31. Le1 Tf3+ 32. Ka4 h3 33. b5 Td4+ 34. b4 cxb5+ 35. Kxb5 Ta3 36. Kc5 Td5+ 37. Kc4 b5# 0:1`*`:cite-ref-steinweder-friedel-16-2[`F5bf`_`[16`#cite-note-steinweder-friedel-16]`_`f]

Von 1967 bis 1970 kam es zu einem Boom in der Schachprogrammierung, der in die `F33f`_`[erste Computerschach-Meisterschaft der Geschichte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=North_American_Computer_Chess_Championship]`_`f mündete, die von der `*`F33f`_`[Association for Computing Machinery`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Association_for_Computing_Machinery]`_`f (ACM)`* ausgetragen wurde. Sieger war `*`F33f`_`[Chess 3.0`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Chess_(Schachprogramm)]`_`f.`*

>>>Peter Jennings

Peter Jennings entwickelte 1976 Microchess für den `F33f`_`[KIM-1`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=KIM-1]`_`f-Heimcomputer. Das Programm wurde bis 1979 über 50.000-mal verkauft und war damit das erste kommerziell erfolgreiche Mikrocomputerprogramm. Aufgrund des nur 1152 Bytes großen RAM-Speichers waren `F33f`_`[Rochade`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rochade]`_`f, `F33f`_`[En passant`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=En_passant]`_`f und `F33f`_`[Bauernumwandlung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bauernumwandlung]`_`f nicht implementiert.

>>>Ken Thompson

→

Hauptartikel

Ken Thompson

Ken Thompson entwickelte 1979 die berühmte Schachmaschine `F33f`_`[Belle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Belle_(Schach)]`_`f, die mit einer Eröffnungsbibliothek und `F33f`_`[Hashtables`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hashtable]`_`f arbeitete.

>>>Feng-hsiung Hsu

→

Hauptartikel

Feng-hsiung Hsu

Das erste Computerprogramm, das einen `F33f`_`[amtierenden Schachweltmeister`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schachweltmeister]`_`f in einer regulären Turnierpartie schlug, war `F33f`_`[Deep Blue`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deep_Blue]`_`f. Entwickelt von `F33f`_`[IBM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IBM]`_`f aufgrund einer Anregung und unter der Leitung des jungen Informatikers Feng-hsiung Hsu, besiegte dieses Programm am 10. Februar 1996 auf einer angepassten und auf Schach optimierten Computerhardware, die ebenfalls von IBM stammte, den damaligen Weltmeister `F33f`_`[Garri Kasparow`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Garri_Kasparow]`_`f in einer dadurch berühmt gewordenen `F33f`_`[Partie`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deep_Blue_–_Kasparow,_Philadelphia_1996,_1._Wettkampfpartie]`_`f. Den Wettkampf konnte Garri Kasparow noch mit 4:2 für sich entscheiden. Eine verbesserte Version von Deep Blue nahm allerdings am 11. Mai 1997 auch diese Hürde und errang in einem zweiten Wettkampf mit der sechsten Turnierpartie den Gesamtsieg über Kasparow mit 3,5:2,5. Deep Blue wurde nach dem spektakulären Sieg demontiert und eingemottet. Die Entstehung des Programms wurde später vom Erfinder in einem Buch beschrieben.`:cite-ref-19[`F5bf`_`[19`#cite-note-19]`_`f]

>>>Chrilly Donninger und Ulf Lorenz

→

Hauptartikel

Christian Donninger

Der Erste, der sich nach Deep Blue wieder auf den Bau spezialisierter Schachhardwarekomponenten als Basis für ein Schachprogramm verlegte, war der österreichische Schachprogrammierer „Chrilly“ Donninger, der zuvor jahrelang mit seinem PC-Programm an Computerschachturnieren teilgenommen hatte. Er entwarf ab 2002 einen Schachcomputer mit von ihm selbst modifizierter Hardware, den er zunächst Brutus nannte. Geldgeber ChessBase zog seine Unterstützung dafür aber nach dem schlechten Abschneiden bei einem Turnier 2003 in Graz zurück; Christian Donninger und Ulf Lorenz verfolgten das Projekt zunächst auf eigene Faust unter dem neuen Namen `F33f`_`[Hydra`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hydra_(Schachcomputer)]`_`f weiter. 2004 fanden Donninger und Lorenz einen neuen Sponsor aus den arabischen Emiraten, PAL Computer Systems. Noch im selben Jahr schlug Hydra den damaligen Computerweltmeister `F33f`_`[Shredder`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Shredder_(Schachprogramm)]`_`f. Im Juni 2005 fand gegen den britischen Großmeister `F33f`_`[Michael Adams`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Michael_Adams_(Schachspieler)]`_`f, damals Siebter der Weltrangliste, ein Wettkampf unter Turnierbedingungen statt, den Hydra überlegen mit 5,5:0,5 gewann.`:cite-ref-20[`F5bf`_`[20`#cite-note-20]`_`f] Dies entspricht einer Turnierperformance von über 3100 Elo-Punkten, so viel, wie bisher kein Mensch erreicht hat. In dieser Version mit 64 Prozessoren galt Hydra seinerzeit als stärkstes schachspielendes DV-System der Welt.

>>Aktuelle Entwicklungen

Die Schachprogrammierung hat in den letzten Jahren durch den Einsatz moderner Technologien und Algorithmen enorme Fortschritte gemacht. Die Verteilung des Rechenaufwandes auf viele einzelne Teilprozesse, die parallel ablaufen können und so `F33f`_`[Multi-Prozessor-Systeme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mehrprozessorsystem]`_`f sinnvoll nutzen, bleibt aufgrund der Komplexität der Baumsuche weiterhin eine Herausforderung. Allerdings nutzen moderne Schachprogramme wie `F33f`_`[Stockfish`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stockfish]`_`f mittlerweile fortschrittliche Parallelisierungsstrategien und profitieren von der Leistungsfähigkeit moderner Hardware.

Auf dem Sektor herkömmlicher PC-Schachprogramme hat sich die parallele Nutzung mehrerer Prozessorkerne bereits seit Jahren etabliert. „Deep-Versionen“ von Engines wie `F33f`_`[Fritz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Fritz_(Schachprogramm)]`_`f und `F33f`_`[Komodo`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Komodo_(Schach)]`_`f nutzen mehrere Prozessorkerne effizient und sind weit verbreitet. Diese Entwicklung wurde durch die Verfügbarkeit von Mehrkernprozessoren und `F33f`_`[64-Bit-Betriebssystemen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=64-Bit-Architektur]`_`f unterstützt, was zu schnelleren und stärkeren Engines geführt hat.

Ein weiterer bedeutender Trend ist die Nutzung von `F33f`_`[Künstlicher Intelligenz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Künstliche_Intelligenz]`_`f und `F33f`_`[maschinellem Lernen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Maschinelles_Lernen]`_`f in Schachprogrammen. `F33f`_`[Leela Chess Zero (LCZero)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Leela_(Software)]`_`f ist ein prominentes Beispiel, das auf `F33f`_`[neuronalen Netzwerken`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Künstliches_neuronales_Netz]`_`f basiert und durch selbstständiges Spielen seine Stärke entwickelt hat. Seit einigen Jahren haben auch andere Engines, wie beispielsweise `F33f`_`[Stockfish`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Stockfish]`_`f, maschinelles Lernen integriert, um ihre Spielstärke weiter zu verbessern. Hier ist die Implementierung spezieller `F33f`_`[neuronaler Netzwerke`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Künstliches_neuronales_Netz]`_`f bemerkenswert, die – anders als zuvor allgemein üblich – `*nicht`* auf `F33f`_`[Grafikprozessoren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafikprozessor]`_`f (GPU) angewiesen sind, sondern bereits auf den zahlreichen Kernen des `F33f`_`[Zentralprozessors`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozessor]`_`f (CPU) eines `F33f`_`[Computers`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computer]`_`f effizient laufen (siehe auch: `*`F33f`_`[Efficiently Updatable Neural Network NNUE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=NNUE]`_`f`*, `F33f`_`[deutsch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Deutsche_Sprache]`_`f „Effizient aktualisierbares neuronales Netz“). Hierdurch wurde ein weiterer bedeutender Sprung in der Spielstärke von Schachprogrammen erreicht, gegen die der Mensch inzwischen völlig chancenlos ist.

Ein weiterer wichtiger Trend besteht in der expliziten Nutzung der vielen GPUs, die moderne `F33f`_`[Grafikkarten`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafikkarte]`_`f in Hülle und Fülle zur Verfügung stellen (siehe auch: `*`F33f`_`[Compute Unified Device Architecture`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=CUDA]`_`f`*, „Einheitliche Gerätearchitektur für Computer“) anstelle von oder in Ergänzung zur CPU. Dies ermöglicht eine deutlich schnellere Verarbeitung der riesigen Datenmengen, die für das Training neuronaler Netzwerke benötigt werden. Engines wie LCZero profitieren stark von dieser Hardware, was sie noch leistungsfähiger macht.

Zusätzlich haben Online-Plattformen und `F33f`_`[Cloud-Computing`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Cloud_Computing]`_`f die Art und Weise verändert, wie Schachprogramme eingesetzt werden. Plattformen wie `F33f`_`[Lichess`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lichess]`_`f und `F33f`_`[Chess.com`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Chess.com]`_`f bieten leistungsstarke Engines zur Analyse und für Turnierspiele, die auf ihren `F33f`_`[Servern`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Server]`_`f laufen und somit die Rechenleistung der Nutzergeräte schonen.

Zusammengefasst zeigen diese Entwicklungen, dass die Schachprogrammierung durch den Einsatz von `F33f`_`[Künstlicher Intelligenz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Künstliche_Intelligenz]`_`f, `F33f`_`[maschinellem Lernen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Maschinelles_Lernen]`_`f und leistungsstarker Hardware wie `F33f`_`[GPUs`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Grafikprozessor]`_`f neue Höhen erreicht hat. Schachprogramme sind heutzutage stärker und effizienter als je zuvor, was die Zukunft dieses spannenden Forschungsgebiets vielversprechend macht.

>>Wettbewerbe

→

Hauptartikel

World Computer Chess Championship

North American Computer Chess Championship

und

Mikrocomputer-Schachweltmeisterschaft

Es gibt verschiedene `F33f`_`[Wettbewerbe`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schachturnier]`_`f, bei denen sich Schachprogramme in ihrer Spielstärke gegenseitig messen, selten auch gegen menschliche Schachspieler. Einer der wichtigsten ist die seit 1974 ausgetragene (offene) Computerschachweltmeisterschaft, die `*World Computer Chess Championship (WCCC),`* die für alle Arten von `F33f`_`[Hard-`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hardware]`_`f und `F33f`_`[Software`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Software]`_`f offensteht. Die älteste Veranstaltung war die von 1970 bis 1994 ausgetragene `*North American Computer Chess Championship (NACCC).`* Darüber hinaus gab es von 1980 bis 2001 eine spezielle Schachweltmeisterschaft nur für `F33f`_`[Mikrocomputer`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mikrocomputer]`_`f, die `*World Microcomputer Chess Championship (WMCCC).`*

>>Elo-Zahlen

→

Hauptartikel

Elo-Zahl

| Rang | Name | Punkte |

|---|---|---|

| 1 | Stockfish 17.1 | 3644 |

| 2 | PlentyChess 7.0.0 | 3642 |

| 3 | Torch v3 | 3634 |

| 4 | Obsidian 16.0 | 3633 |

| 5 | Reckless 0.8.0 | 3631 |

| 6 | Alexandria 8.1.2 | 3629 |

| 7 | Komodo Dragon 3.3 | 3625 |

| 8 | Caissa 1.23 | 3621 |

| 9 | Clover 9.0 | 3619 |

| 10 | Integral v7 | 3618 |

Auch Schachprogrammen kann man eine Elo-Zahl geben, die ihre Spielstärke beschreibt. Zum Vergleich: Ein Schachweltmeister von heute bewegt sich im Bereich um Elo 2850. Die Elo-Zahlen in Computer-Ranglisten sind aber nicht ohne weiteres mit denen menschlicher Schachspieler zu vergleichen, da sie praktisch ausschließlich durch Partien zwischen Computern ermittelt wurden. Hinsichtlich der absoluten Größe der Wertungszahlen `*fehlt eine Kalibrierung`* zwischen Leistungsskalen menschlicher Meisterspieler und jenen von Schachprogrammen; diese würde zahlreiche ernste Wettkampfpartien zwischen beiden Spielergruppen erfordern. D. h., das Zahlenniveau in reinen Computerwertungslisten muss notgedrungen von einer plausiblen oder praxisgeeigneten Annahme ausgehen, und die konkreten Resultate der Programme gegeneinander bestimmen lediglich die `*Rangfolge und die Abstände`* zwischen ihren Wertungszahlen.

Wegen der grundsätzlich unterschiedlichen Methoden von Menschen und Computerprogrammen beim Schachspiel ist eine hohe Spielstärke gegen ein anderes Schachprogramm nicht zwingend gleichbedeutend mit entsprechend besserer Leistung gegenüber einem menschlichen Gegner. Wettbewerbe von Schachprogrammen untereinander sagen daher nur bedingt etwas über die Spielstärke gegen Menschen aus. Jedoch hat die Praxis gezeigt, dass eine hohe Spielstärke gegen Programme in der Regel auch eine hohe Spielstärke gegen Menschen bedeutet. Das Programm `F33f`_`[Rybka`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rybka]`_`f hat gegen verschiedene Großmeister – teilweise mit `F33f`_`[einem Bauern Vorgabe`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Vorgabepartie]`_`f – gewinnen können. Andere Programme sind inzwischen noch spielstärker.

Eine Bewertung der Spielstärke von Schachprogrammen und Schachcomputern ist darüber hinaus auch mit Hilfe einer festgelegten Reihe von Schachproblemen möglich. Zum Beispiel besteht ein als `F33f`_`[BT2450`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=BT2450]`_`f bezeichneter Test aus 30 Stellungen, zu denen der jeweilige Lösungszug zu finden ist. Aus den dafür benötigten Zeiten für alle Stellungen wird ein BT2450-Testwert berechnet, der mit der Elo-Zahl von menschlichen Spielern begrenzt vergleichbar ist. Es gibt inzwischen weitere, zum Teil umfangreichere und/oder schwierigere Tests, die innerhalb der Computerschach-Community erstellt und angewandt werden.

>>Siehe auch

• `F33f`_`[Chess Programming Wiki`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Chess_Programming_Wiki]`_`f (CPW), englischsprachiges `F33f`_`[Wiki`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Wiki]`_`f zum Thema

• `F33f`_`[Computer Chess Rating Lists`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computer_Chess_Rating_Lists]`_`f (CCRL)

• `F33f`_`[Forsyth-Edwards-Notation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Forsyth-Edwards-Notation]`_`f (FEN)

>>Quellen

`:cite-note-1`!1.`! `F0af`_`[↑`#cite-ref-1]`_`f Jon Dart: `*Arasan chess.`* In: `*ArasanChess.org.`* Abgerufen am 9. Januar 2021.

`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f `*Knights.`* In: `*Sourceforge.net.`* Abgerufen am 9. Januar 2021.

`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f Niyas Khasanov: `*Ufim.`* In: `*WBEC-Ridderkerk.nl.`* Abgerufen am 9. Januar 2021.

`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f `*TCEC Chess.`* Abgerufen am 14. März 2024 (Heruntersollen zu Saisons für Informationen zu den jeweiligen Saisons und Ergebnissen.).

`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f `*CEGT-Rangliste.`* Abgerufen am 9. Januar 2021.

`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f Herbert Braun: `*Plagiatsvorwurf gegen Computerschach-Weltmeister.`* In: `*Heise.de.`* 1. März 2011, abgerufen am 9. Januar 2021.

`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f `*CCRL 40/4.`* Abgerufen am 9. Januar 2021.

`:cite-note-8`!8.`! `F0af`_`[↑`#cite-ref-8]`_`f `*CCRL 40/40.`* Abgerufen am 9. Januar 2021.

`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f `*CCRL 404FRC.`* Abgerufen am 9. Januar 2021.

`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f `*CEGT 40/4.`* Abgerufen am 9. Januar 2021.

`:cite-note-11`!11.`! `F0af`_`[↑`#cite-ref-11]`_`f `*CEGT 40/20.`* Abgerufen am 9. Januar 2021.

`:cite-note-12`!12.`! `F0af`_`[↑`#cite-ref-12]`_`f `*Lomonosov Endgame Tablebases.`* In: `*chessok.com.`* Abgerufen am 9. Januar 2021.

`:cite-note-13`!13.`! `F0af`_`[↑`#cite-ref-13]`_`f `*Welcome to the online 7-man tablebases.`* In: `*tb7.chessok.com.`* Abgerufen am 9. Januar 2021.

`:cite-note-14`!14.`! `F0af`_`[↑`#cite-ref-14]`_`f Raúl Rojas u. a. (FU Berlin): `*Konrad Zuses Plankalkül – Seine Genese und eine moderne Implementierung.`* (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 23. April 2012 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*). In: `*zib.de.`* Konrad Zuse Internet Archive. Abgerufen am 9. Januar 2021.

`:cite-note-15`!15.`! `F0af`_`[↑`#cite-ref-15]`_`f Stefan Klein: Wie wir die Welt verändern: Eine kurze Geschichte des menschlichen Geistes. S. Fischer, 2021, ISBN 978-3-10-002492-3, S. 209.

`:cite-note-steinweder-friedel-16`!16.`! `F0af`_`[↑`#cite-ref-steinweder-friedel-16-0]`_`f Dieter Steinweder, Frederic A. Friedel: `*Schach am PC.`* Markt und Technik, Haar b. München 1995, ISBN 3-87791-522-1, S. 33–35.

`:cite-note-17`!17.`! `F0af`_`[↑`#cite-ref-17]`_`f Frederic Friedel: `*Reconstructing Turing’s “Paper Machine”.`* In: `*`F33f`_`[ChessBase`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ChessBase]`_`f.com.`* 23. September 2017, abgerufen am 9. Januar 2021 (englisch).

`:cite-note-18`!18.`! `F0af`_`[↑`#cite-ref-18]`_`f Eric van Reem: `*Der Traum vom Computerschach. Eine kleine Geschichte des Computerschachs.`* In: `*scrkuppenheim.de.`* Januar 2003, abgerufen am 9. Januar 2021.

`:cite-note-19`!19.`! `F0af`_`[↑`#cite-ref-19]`_`f Feng-hsiung Hsu: `*Behind Deep Blue.`* Princeton University Press, Princeton/Oxford 2002, ISBN 0-691-09065-3.

`:cite-note-20`!20.`! `F0af`_`[↑`#cite-ref-20]`_`f Lars Bremer: `*Computerschach: Großmeister von Hydra deklassiert.`* In: `*Heise.de.`* 28. Juni 2005, abgerufen am 9. Januar 2021.

`:cite-note-21`!1.`! `*Rating list.`* In: `*computerchess.org.uk.`* 17. Oktober 2025, abgerufen am 22. Oktober 2025.

>>Literatur

• Rainer Bartel, Hans-Joachim Kraas, Günther Schrüfer: `*Das große Computerschachbuch.`* Data Becker, Düsseldorf 1985, ISBN 3-89011-117-3 (gute Einführung in die Programmierung von Computerschach mit Beispielen in `F33f`_`[BASIC`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=BASIC]`_`f).

• `*`F33f`_`[Computerschach und Spiele`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerschach_und_Spiele]`_`f (CSS).`* 1/1986 bis 6/2004 (danach nur noch online); Zeitschrift überwiegend zum Thema Computerschach.

• `F33f`_`[Claude Shannon`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Claude_Shannon]`_`f: `*Programming a Computer for Playing Chess.`* In: `*Philosophical Magazine.`* 1950/41, S. 256–257.

• Claude Shannon: `*Programming a Computer to Play Chess.`* In: `*Scientific American.`* 2/1950, S. 48–51.

• `F33f`_`[Botvinnik`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Botvinnik]`_`f: `*Meine neuen Ideen zur Schachprogrammierung.`* Springer 1982, ISBN 3-540-11094-1.

• `F33f`_`[Botvinnik`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Botvinnik]`_`f: `*Über den Schach-Algorithmus und dessen Anwendung in der Langzeitplanung.`*, dt. Dortmund 1992

• `F33f`_`[Dieter Steinwender`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dieter_Steinwender]`_`f, `F33f`_`[Frederic A. Friedel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Frederic_Friedel]`_`f: `*Schach am PC.`* Markt und Technik, Haar bei München 1995, ISBN 3-87791-522-1 (Geschichte des Computerschachs, didaktisches Schachprogramm mit Quellen in BASIC und `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f, inkl. CD).

>>Weblinks

• `*Seite von Ed Schröder.`* (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 30. Januar 2010 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*). Autor von Rebel und ProDeo, sehr viele Informationen zum Thema Computerschach und detaillierte Beschreibungen zum `*Innenleben von Rebel.`* (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 31. Mai 2010 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*). (Englisch).

• `*Schachprogramm Micro-Max.`* Schachprogramm in C mit weniger als 2000 Byte Quellcode (englisch).

• `*Das erste Schachprogramm der Welt als modernes Java-Applet.`*

• B. Monien, U. Lorenz, D. Warner: `*Der Alphabeta-Algorithmus. Wie bringe ich meinen Computer zum Schachspielen?`* (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 15. Dezember 2015 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*). 2006.

• `*9. Computerschach-Weltmeisterschaft vom 14. bis 20. Juni 1999 in Paderborn.`* Bericht auf `F33f`_`[TeleSchach`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=TeleSchach]`_`f.

• `*Online-Fortsetzung der ehem. Zeitschrift Computerschach und Spiele.`*

• `*SSDF Computer-Rangliste.`*

• `*CEGT-Rangliste.`*

• `*Microchess – das erste Mikrocomputer Schachprogramm.`*

• `*Wiki zur Schachprogrammierung (englisch).`* (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 20. Januar 2010 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*).

`c`F0af`_`[↑ Back to top`#top]`_`f`a